// MD5Checksum.cpp: implementation of the MD5Checksum class.
//
//////////////////////////////////////////////////////////////////////


/****************************************************************************************
This software is derived from the RSA Data Security, Inc. MD5 Message-Digest Algorithm.
Incorporation of this statement is a condition of use; please see the RSA
Data Security Inc copyright notice below:-

Copyright (C) 1990-2, RSA Data Security, Inc. Created 1990. All
rights reserved.

RSA Data Security, Inc. makes no representations concerning either
the merchantability of this software or the suitability of this
software for any particular purpose. It is provided "as is"
without express or implied warranty of any kind.

These notices must be retained in any copies of any part of this
documentation and/or software.

Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All
rights reserved.
License to copy and use this software is granted provided that it
is identified as the "RSA Data Security, Inc. MD5 Message-Digest
Algorithm" in all material mentioning or referencing this software
or this function.
License is also granted to make and use derivative works provided
that such works are identified as "derived from the RSA Data
Security, Inc. MD5 Message-Digest Algorithm" in all material
mentioning or referencing the derived work.
RSA Data Security, Inc. makes no representations concerning either
the merchantability of this software or the suitability of this
software for any particular purpose. It is provided "as is"
without express or implied warranty of any kind.

These notices must be retained in any copies of any part of this
documentation and/or software.
*****************************************************************************************/

/****************************************************************************************
This implementation of the RSA MD5 Algorithm was written by Langfine Ltd
(www.langfine.com).

Langfine Ltd makes no representations concerning either
the merchantability of this software or the suitability of this
software for any particular purpose. It is provided "as is"
without express or implied warranty of any kind.

In addition to the above, Langfine make no warrant or assurances regarding the
accuracy of this implementation of the MD5 checksum algorithm nor any assurances regarding
its suitability for any purposes.

This implementation may be used freely provided that Langfine is credited
in a copyright or similar notices (eg, RSA MD5 Algorithm implemented by Langfine
Ltd.) and provided that the RSA Data Security notices are complied with.
*/
#include "MD5Checksum.h"
#include "MD5ChecksumDefines.h"



/*****************************************************************************************
FUNCTION:       CMD5Checksum::GetMD5
DETAILS:        static, public
DESCRIPTION:    Gets the MD5 checksum for a specified file
RETURNS:        CString : the hexadecimal MD5 checksum for the specified file
ARGUMENTS:      CString& strFilePath : the full pathname of the specified file
NOTES:          Provides an interface to the CMD5Checksum class. 'strFilePath' name should
                hold the full pathname of the file, eg C:\My Documents\Arcticle.txt.
                NB. If any problems occur with opening or reading this file, a CFileException
                will be thrown; callers of this function should be ready to catch this
                exception.
*****************************************************************************************/
tstring CMD5Checksum::GetMD5(const tstring &strFilePath, long long nLength)
{
    //open the file as a binary file in readonly mode, denying write access
    FILE *file = NULL;
    file = fopen(strFilePath.c_str(), _T("rb"));
    if (!file)
    {
        return _T("");
    }
    //the file has been successfully opened, so now get and return its checksum
    tstring strRet;
    strRet = GetMD5(file, nLength);
    fclose(file);
    return strRet;
}

unsigned char *CMD5Checksum::_GetMD5(const tstring &strFilePath, long long nLength)
{
    //open the file as a binary file in readonly mode, denying write access
    FILE *file = NULL;
    file = fopen(strFilePath.c_str(), _T("rb"));
    if (!file)
    {
        return NULL;
    }

    //the file has been successfully opened, so now get and return its checksum
    unsigned char *pRet;
    pRet = _GetMD5(file, nLength);
    fclose(file);
    return pRet;
}

/*****************************************************************************************
FUNCTION:       CMD5Checksum::GetMD5
DETAILS:        static, public
DESCRIPTION:    Gets the MD5 checksum for a specified file
RETURNS:        CString : the hexadecimal MD5 checksum for the specified file
ARGUMENTS:      CFile& File : the specified file
NOTES:          Provides an interface to the CMD5Checksum class. 'File' should be open in
                binary readonly mode before calling this function.
                NB. Callers of this function should be ready to catch any CFileException
                thrown by the CFile functions
*****************************************************************************************/
tstring CMD5Checksum::GetMD5(FILE *File, long long nLength)
{
    try
    {
        CMD5Checksum MD5Checksum;       //checksum object
        int nCount = 0;             //number of bytes read from the file
        const int nBufferSize = 1024;   //checksum the file in blocks of 1024 bytes
        BYTE Buffer[nBufferSize];       //buffer for data read from the file

        long long uiFileSize = nLength;
        //fseeko(File,0,SEEK_END);
        //uiFileSize = ftello(File);
        fseeko(File, 0, SEEK_SET);
        //checksum the file in blocks of 1024 bytes
        while (uiFileSize > 0)
        {
            nCount = (uiFileSize >= nBufferSize) ? nBufferSize : uiFileSize;
            nCount = fread(Buffer, 1, nCount, File);
            uiFileSize -= nCount;
            MD5Checksum.Update(Buffer, nCount);
        }
        //finalise the checksum and return it
        return MD5Checksum.Final();
    }

    //report any file exceptions in debug mode only
    catch (...)
    {
        return _T("");
    }
}

unsigned char *CMD5Checksum::_GetMD5(FILE *File, long long nLength)
{
    try
    {
        CMD5Checksum MD5Checksum;       //checksum object
        int nCount = 0;             //number of bytes read from the file
        const int nBufferSize = 1024;   //checksum the file in blocks of 1024 bytes
        BYTE Buffer[nBufferSize];       //buffer for data read from the file

        long long uiFileSize = nLength;
        //      fseeko(File,0,SEEK_END);
        //      uiFileSize = ftello(File);
        fseeko(File, 0, SEEK_SET);
        //checksum the file in blocks of 1024 bytes
        while (uiFileSize > 0)
        {
            nCount = (uiFileSize >= nBufferSize) ? nBufferSize : uiFileSize;
            nCount = fread(Buffer, 1, nCount, File);
            uiFileSize -= nCount;
            MD5Checksum.Update(Buffer, nCount);
        }

        //finalise the checksum and return it
        return MD5Checksum.FinalChar();
    }

    //report any file exceptions in debug mode only
    catch (...)
    {
        return NULL;
    }
}

/*****************************************************************************************
FUNCTION:       CMD5Checksum::GetMD5
DETAILS:        static, public
DESCRIPTION:    Gets the MD5 checksum for data in a BYTE array
RETURNS:        CString : the hexadecimal MD5 checksum for the specified data
ARGUMENTS:      BYTE* pBuf  :   pointer to the BYTE array
                UINT nLength :  number of BYTEs of data to be checksumed
NOTES:          Provides an interface to the CMD5Checksum class. Any data that can
                be cast to a BYTE array of known length can be checksummed by this
                function. Typically, CString and char arrays will be checksumed,
                although this function can be used to check the integrity of any BYTE array.
                A buffer of zero length can be checksummed; all buffers of zero length
                will return the same checksum.
*****************************************************************************************/
tstring CMD5Checksum::GetMD5(BYTE *pBuf, UINT nLength)
{

    //calculate and return the checksum
    CMD5Checksum MD5Checksum;
    MD5Checksum.Update(pBuf, nLength);
    return MD5Checksum.Final();
}

unsigned char   *CMD5Checksum::_GetMD5(BYTE *pBuf, UINT nLength)
{
    //calculate and return the checksum
    CMD5Checksum MD5Checksum;
    MD5Checksum.Update(pBuf, nLength);
    return MD5Checksum.FinalChar();
}

/*****************************************************************************************
FUNCTION:       CMD5Checksum::RotateLeft
DETAILS:        private
DESCRIPTION:    Rotates the bits in a 32 bit DWORD left by a specified amount
RETURNS:        The rotated DWORD
ARGUMENTS:      DWORD x : the value to be rotated
                int n   : the number of bits to rotate by
*****************************************************************************************/
DWORD CMD5Checksum::RotateLeft(DWORD x, int n)
{
    //check that DWORD is 4 bytes long - true in Visual C++ 6 and 32 bit Windows
    assert(sizeof(x) == 4);

    //rotate and return x
    return (x << n) | (x >> (32 - n));
}


/*****************************************************************************************
FUNCTION:       CMD5Checksum::FF
DETAILS:        protected
DESCRIPTION:    Implementation of basic MD5 transformation algorithm
RETURNS:        none
ARGUMENTS:      DWORD &A, B, C, D : Current (partial) checksum
                DWORD X           : Input data
                DWORD S           : MD5_SXX Transformation constant
                DWORD T           : MD5_TXX Transformation constant
NOTES:          None
*****************************************************************************************/
void CMD5Checksum::FF(DWORD &A, DWORD B, DWORD C, DWORD D, DWORD X, DWORD S, DWORD T)
{
    DWORD F = (B & C) | (~B & D);
    A += F + X + T;
    A = RotateLeft(A, S);
    A += B;
}


/*****************************************************************************************
FUNCTION:       CMD5Checksum::GG
DETAILS:        protected
DESCRIPTION:    Implementation of basic MD5 transformation algorithm
RETURNS:        none
ARGUMENTS:      DWORD &A, B, C, D : Current (partial) checksum
                DWORD X           : Input data
                DWORD S           : MD5_SXX Transformation constant
                DWORD T           : MD5_TXX Transformation constant
NOTES:          None
*****************************************************************************************/
void CMD5Checksum::GG(DWORD &A, DWORD B, DWORD C, DWORD D, DWORD X, DWORD S, DWORD T)
{
    DWORD G = (B & D) | (C & ~D);
    A += G + X + T;
    A = RotateLeft(A, S);
    A += B;
}


/*****************************************************************************************
FUNCTION:       CMD5Checksum::HH
DETAILS:        protected
DESCRIPTION:    Implementation of basic MD5 transformation algorithm
RETURNS:        none
ARGUMENTS:      DWORD &A, B, C, D : Current (partial) checksum
                DWORD X           : Input data
                DWORD S           : MD5_SXX Transformation constant
                DWORD T           : MD5_TXX Transformation constant
NOTES:          None
*****************************************************************************************/
void CMD5Checksum::HH(DWORD &A, DWORD B, DWORD C, DWORD D, DWORD X, DWORD S, DWORD T)
{
    DWORD H = (B ^ C ^ D);
    A += H + X + T;
    A = RotateLeft(A, S);
    A += B;
}


/*****************************************************************************************
FUNCTION:       CMD5Checksum::II
DETAILS:        protected
DESCRIPTION:    Implementation of basic MD5 transformation algorithm
RETURNS:        none
ARGUMENTS:      DWORD &A, B, C, D : Current (partial) checksum
                DWORD X           : Input data
                DWORD S           : MD5_SXX Transformation constant
                DWORD T           : MD5_TXX Transformation constant
NOTES:          None
*****************************************************************************************/
void CMD5Checksum::II(DWORD &A, DWORD B, DWORD C, DWORD D, DWORD X, DWORD S, DWORD T)
{
    DWORD I = (C ^ (B | ~D));
    A += I + X + T;
    A = RotateLeft(A, S);
    A += B;
}


/*****************************************************************************************
FUNCTION:       CMD5Checksum::ByteToDWord
DETAILS:        private
DESCRIPTION:    Transfers the data in an 8 bit array to a 32 bit array
RETURNS:        void
ARGUMENTS:      DWORD* Output : the 32 bit (unsigned long) destination array
                BYTE* Input   : the 8 bit (unsigned char) source array
                UINT nLength  : the number of 8 bit data items in the source array
NOTES:          Four BYTES from the input array are transferred to each DWORD entry
                of the output array. The first BYTE is transferred to the bits (0-7)
                of the output DWORD, the second BYTE to bits 8-15 etc.
                The algorithm assumes that the input array is a multiple of 4 bytes long
                so that there is a perfect fit into the array of 32 bit words.
*****************************************************************************************/
void CMD5Checksum::ByteToDWord(DWORD *Output, BYTE *Input, UINT nLength)
{

    //initialisations
    UINT i = 0; //index to Output array
    UINT j = 0; //index to Input array

    //transfer the data by shifting and copying
    for (; j < nLength; i++, j += 4)
    {
        Output[i] = (UINT)Input[j]          |
                    (UINT)Input[j + 1] << 8   |
                    (UINT)Input[j + 2] << 16 |
                    (UINT)Input[j + 3] << 24;
    }
}

/*****************************************************************************************
FUNCTION:       CMD5Checksum::Transform
DETAILS:        protected
DESCRIPTION:    MD5 basic transformation algorithm;  transforms 'm_lMD5'
RETURNS:        void
ARGUMENTS:      BYTE Block[64]
NOTES:          An MD5 checksum is calculated by four rounds of 'Transformation'.
                The MD5 checksum currently held in m_lMD5 is merged by the
                transformation process with data passed in 'Block'.
*****************************************************************************************/
void CMD5Checksum::Transform(BYTE Block[64])
{
    //initialise local data with current checksum
    UINT a = m_lMD5[0];
    UINT b = m_lMD5[1];
    UINT c = m_lMD5[2];
    UINT d = m_lMD5[3];

    //copy BYTES from input 'Block' to an array of UINTS 'X'
    UINT X[16];
    ByteToDWord(X, Block, 64);

    //Perform Round 1 of the transformation
    FF(a, b, c, d, X[ 0], MD5_S11, MD5_T01);
    FF(d, a, b, c, X[ 1], MD5_S12, MD5_T02);
    FF(c, d, a, b, X[ 2], MD5_S13, MD5_T03);
    FF(b, c, d, a, X[ 3], MD5_S14, MD5_T04);
    FF(a, b, c, d, X[ 4], MD5_S11, MD5_T05);
    FF(d, a, b, c, X[ 5], MD5_S12, MD5_T06);
    FF(c, d, a, b, X[ 6], MD5_S13, MD5_T07);
    FF(b, c, d, a, X[ 7], MD5_S14, MD5_T08);
    FF(a, b, c, d, X[ 8], MD5_S11, MD5_T09);
    FF(d, a, b, c, X[ 9], MD5_S12, MD5_T10);
    FF(c, d, a, b, X[10], MD5_S13, MD5_T11);
    FF(b, c, d, a, X[11], MD5_S14, MD5_T12);
    FF(a, b, c, d, X[12], MD5_S11, MD5_T13);
    FF(d, a, b, c, X[13], MD5_S12, MD5_T14);
    FF(c, d, a, b, X[14], MD5_S13, MD5_T15);
    FF(b, c, d, a, X[15], MD5_S14, MD5_T16);

    //Perform Round 2 of the transformation
    GG(a, b, c, d, X[ 1], MD5_S21, MD5_T17);
    GG(d, a, b, c, X[ 6], MD5_S22, MD5_T18);
    GG(c, d, a, b, X[11], MD5_S23, MD5_T19);
    GG(b, c, d, a, X[ 0], MD5_S24, MD5_T20);
    GG(a, b, c, d, X[ 5], MD5_S21, MD5_T21);
    GG(d, a, b, c, X[10], MD5_S22, MD5_T22);
    GG(c, d, a, b, X[15], MD5_S23, MD5_T23);
    GG(b, c, d, a, X[ 4], MD5_S24, MD5_T24);
    GG(a, b, c, d, X[ 9], MD5_S21, MD5_T25);
    GG(d, a, b, c, X[14], MD5_S22, MD5_T26);
    GG(c, d, a, b, X[ 3], MD5_S23, MD5_T27);
    GG(b, c, d, a, X[ 8], MD5_S24, MD5_T28);
    GG(a, b, c, d, X[13], MD5_S21, MD5_T29);
    GG(d, a, b, c, X[ 2], MD5_S22, MD5_T30);
    GG(c, d, a, b, X[ 7], MD5_S23, MD5_T31);
    GG(b, c, d, a, X[12], MD5_S24, MD5_T32);

    //Perform Round 3 of the transformation
    HH(a, b, c, d, X[ 5], MD5_S31, MD5_T33);
    HH(d, a, b, c, X[ 8], MD5_S32, MD5_T34);
    HH(c, d, a, b, X[11], MD5_S33, MD5_T35);
    HH(b, c, d, a, X[14], MD5_S34, MD5_T36);
    HH(a, b, c, d, X[ 1], MD5_S31, MD5_T37);
    HH(d, a, b, c, X[ 4], MD5_S32, MD5_T38);
    HH(c, d, a, b, X[ 7], MD5_S33, MD5_T39);
    HH(b, c, d, a, X[10], MD5_S34, MD5_T40);
    HH(a, b, c, d, X[13], MD5_S31, MD5_T41);
    HH(d, a, b, c, X[ 0], MD5_S32, MD5_T42);
    HH(c, d, a, b, X[ 3], MD5_S33, MD5_T43);
    HH(b, c, d, a, X[ 6], MD5_S34, MD5_T44);
    HH(a, b, c, d, X[ 9], MD5_S31, MD5_T45);
    HH(d, a, b, c, X[12], MD5_S32, MD5_T46);
    HH(c, d, a, b, X[15], MD5_S33, MD5_T47);
    HH(b, c, d, a, X[ 2], MD5_S34, MD5_T48);

    //Perform Round 4 of the transformation
    II(a, b, c, d, X[ 0], MD5_S41, MD5_T49);
    II(d, a, b, c, X[ 7], MD5_S42, MD5_T50);
    II(c, d, a, b, X[14], MD5_S43, MD5_T51);
    II(b, c, d, a, X[ 5], MD5_S44, MD5_T52);
    II(a, b, c, d, X[12], MD5_S41, MD5_T53);
    II(d, a, b, c, X[ 3], MD5_S42, MD5_T54);
    II(c, d, a, b, X[10], MD5_S43, MD5_T55);
    II(b, c, d, a, X[ 1], MD5_S44, MD5_T56);
    II(a, b, c, d, X[ 8], MD5_S41, MD5_T57);
    II(d, a, b, c, X[15], MD5_S42, MD5_T58);
    II(c, d, a, b, X[ 6], MD5_S43, MD5_T59);
    II(b, c, d, a, X[13], MD5_S44, MD5_T60);
    II(a, b, c, d, X[ 4], MD5_S41, MD5_T61);
    II(d, a, b, c, X[11], MD5_S42, MD5_T62);
    II(c, d, a, b, X[ 2], MD5_S43, MD5_T63);
    II(b, c, d, a, X[ 9], MD5_S44, MD5_T64);

    //add the transformed values to the current checksum
    m_lMD5[0] += a;
    m_lMD5[1] += b;
    m_lMD5[2] += c;
    m_lMD5[3] += d;
}


/*****************************************************************************************
CONSTRUCTOR:    CMD5Checksum
DESCRIPTION:    Initialises member data
ARGUMENTS:      None
NOTES:          None
*****************************************************************************************/
CMD5Checksum::CMD5Checksum()
{
    // zero members
    memset(m_lpszBuffer, 0, 64);
    m_nCount[0] = m_nCount[1] = 0;
    m_pBuffer = NULL;
    // Load magic state initialization constants
    m_lMD5[0] = MD5_INIT_STATE_0;
    m_lMD5[1] = MD5_INIT_STATE_1;
    m_lMD5[2] = MD5_INIT_STATE_2;
    m_lMD5[3] = MD5_INIT_STATE_3;
    m_pBuffer = NULL;
}

/*****************************************************************************************
FUNCTION:       CMD5Checksum::DWordToByte
DETAILS:        private
DESCRIPTION:    Transfers the data in an 32 bit array to a 8 bit array
RETURNS:        void
ARGUMENTS:      BYTE* Output  : the 8 bit destination array
                DWORD* Input  : the 32 bit source array
                UINT nLength  : the number of 8 bit data items in the source array
NOTES:          One DWORD from the input array is transferred into four BYTES
                in the output array. The first (0-7) bits of the first DWORD are
                transferred to the first output BYTE, bits bits 8-15 are transferred from
                the second BYTE etc.

                The algorithm assumes that the output array is a multiple of 4 bytes long
                so that there is a perfect fit of 8 bit BYTES into the 32 bit DWORDs.
*****************************************************************************************/
void CMD5Checksum::DWordToByte(BYTE *Output, DWORD *Input, UINT nLength)
{
    //transfer the data by shifting and copying
    UINT i = 0;
    UINT j = 0;
    for (; j < nLength; i++, j += 4)
    {
        Output[j] = (UCHAR)(Input[i] & 0xff);
        Output[j + 1] = (UCHAR)((Input[i] >> 8) & 0xff);
        Output[j + 2] = (UCHAR)((Input[i] >> 16) & 0xff);
        Output[j + 3] = (UCHAR)((Input[i] >> 24) & 0xff);
    }
}


/*****************************************************************************************
FUNCTION:       CMD5Checksum::Final
DETAILS:        protected
DESCRIPTION:    Implementation of main MD5 checksum algorithm; ends the checksum calculation.
RETURNS:        CString : the final hexadecimal MD5 checksum result
ARGUMENTS:      None
NOTES:          Performs the final MD5 checksum calculation ('Update' does most of the work,
                this function just finishes the calculation.)
*****************************************************************************************/
tstring CMD5Checksum::Final()
{
    //Save number of bits
    BYTE Bits[8];
    DWordToByte(Bits, m_nCount, 8);

    //Pad out to 56 mod 64.
    UINT nIndex = (UINT)((m_nCount[0] >> 3) & 0x3f);
    UINT nPadLen = (nIndex < 56) ? (56 - nIndex) : (120 - nIndex);
    Update(PADDING, nPadLen);

    //Append length (before padding)
    Update(Bits, 8);

    //Store final state in 'lpszMD5'
    const int nMD5Size = 16;
    unsigned char lpszMD5[ nMD5Size ];
    DWordToByte(lpszMD5, m_lMD5, nMD5Size);

    //Convert the hexadecimal checksum to a CString
    tstring strMD5;
    tchar str[10];
    strMD5 = _T("");
    for (int i = 0; i < nMD5Size; i++)
    {
        if (lpszMD5[i] == 0)
        {
            _tcscpy(str, _T("00"));
        }
        else if (lpszMD5[i] <= 15)
        {
            _stprintf(str, _T("0%x"), lpszMD5[i]);
        }
        else
        {
            _stprintf(str, _T("%x"), lpszMD5[i]);
        }

        assert(_tcslen(str) == 2);
        strMD5 += str;
    }
    assert(strMD5.size() == 32);
    return strMD5;
}

/*****************************************************************************************
FUNCTION:       CMD5Checksum::Final
DETAILS:        protected
DESCRIPTION:    Implementation of main MD5 checksum algorithm; ends the checksum calculation.
RETURNS:        CString : the final hexadecimal MD5 checksum result
ARGUMENTS:      None
NOTES:          Performs the final MD5 checksum calculation ('Update' does most of the work,
                this function just finishes the calculation.)
*****************************************************************************************/
unsigned char *CMD5Checksum::FinalChar()
{
    //Save number of bits
    BYTE Bits[8];
    DWordToByte(Bits, m_nCount, 8);

    //Pad out to 56 mod 64.
    UINT nIndex = (UINT)((m_nCount[0] >> 3) & 0x3f);
    UINT nPadLen = (nIndex < 56) ? (56 - nIndex) : (120 - nIndex);
    Update(PADDING, nPadLen);

    //Append length (before padding)
    Update(Bits, 8);

    //Store final state in 'lpszMD5'
    const int nMD5Size = 16;
    if (m_pBuffer)
    {
        delete []m_pBuffer;
        m_pBuffer = NULL;
    }
    m_pBuffer = new BYTE[nMD5Size];
    DWordToByte(m_pBuffer, m_lMD5, nMD5Size);
    return m_pBuffer;
    //  unsigned char lpszMD5[ nMD5Size ];
    //  DWordToByte( lpszMD5, m_lMD5, nMD5Size );

    //  return lpszMD5;
}

/*****************************************************************************************
FUNCTION:       CMD5Checksum::Update
DETAILS:        protected
DESCRIPTION:    Implementation of main MD5 checksum algorithm
RETURNS:        void
ARGUMENTS:      BYTE* Input    : input block
                UINT nInputLen : length of input block
NOTES:          Computes the partial MD5 checksum for 'nInputLen' bytes of data in 'Input'
*****************************************************************************************/
void CMD5Checksum::Update(BYTE *Input,  UINT nInputLen)
{
    //Compute number of bytes mod 64
    UINT nIndex = (UINT)((m_nCount[0] >> 3) & 0x3F);

    //Update number of bits
    if ((m_nCount[0] += nInputLen << 3)  < (nInputLen << 3))
    {
        m_nCount[1]++;
    }
    m_nCount[1] += (nInputLen >> 29);

    //Transform as many times as possible.
    UINT i = 0;
    UINT nPartLen = 64 - nIndex;
    if (nInputLen >= nPartLen)
    {
        memcpy(&m_lpszBuffer[nIndex], Input, nPartLen);
        Transform(m_lpszBuffer);
        for (i = nPartLen; i + 63 < nInputLen; i += 64)
        {
            Transform(&Input[i]);
        }
        nIndex = 0;
    }
    else
    {
        i = 0;
    }

    // Buffer remaining input
    memcpy(&m_lpszBuffer[nIndex], &Input[i], nInputLen - i);
}


